#pragma once

/* 消息数据结构ODB映射对象 */

#include <string>
#include <cstddef> // std::size_t
#include <odb/nullable.hxx>
#include <odb/core.hxx>
#include <boost/date_time/posix_time/posix_time.hpp>

namespace ChatSystem
{
    #pragma db object table("message")
    class Message
    {
    public:
        Message(){}
        Message(const std::string& message_id,
            const std::string& chat_session_id,
            const std::string& user_id,
            unsigned char message_type,
            const boost::posix_time::ptime& create_time)
        :_message_id(message_id)
        ,_chat_session_id(chat_session_id)
        ,_user_id(user_id)
        ,_message_type(message_type)
        ,_create_time(create_time)
        {}
        ~Message()
        {}

        //获取消息ID
        std::string message_id()const
        {
            return _message_id;
        }
        std::string message_id()
        {
            return _message_id;
        }
        //修改消息ID
        void message_id(const std::string& val)
        {
            _message_id = val;
        }

        //获取聊天会话ID
        std::string chat_session_id()const
        {
            return _chat_session_id;
        }
        std::string chat_session_id()
        {
            return _chat_session_id;
        }
        //修改聊天会话ID
        void chat_session_id(const std::string& val)
        {
            _chat_session_id = val;
        }

        //获取用户ID
        std::string user_id() const
        {
            return _user_id;
        }
        //获取用户ID
        std::string user_id()
        {
            return _user_id;
        }
        //修改用户ID
        void user_id(const std::string& uid)
        {
            _user_id = uid;
        }

        //获取消息类型
        unsigned char message_type() const
        {
            return _message_type;
        }
        //获取消息类型
        unsigned char message_type()
        {
            return _message_type;
        }
        //修改消息类型
        void message_type(const unsigned char val)
        {
            _message_type = val;
        }

        //获取消息产生时间
        boost::posix_time::ptime create_time() const
        {
            return _create_time;
        }
        //获取消息产生时间
        boost::posix_time::ptime create_time()
        {
            return _create_time;
        }
        //修改消息产生时间
        void create_time(const boost::posix_time::ptime& val)
        {
            _create_time = val;
        }

        //获取消息内容
        std::string content() const
        {
            if(!_content)
            {
                return std::string();
            }
            return *_content;
        }
        //获取消息内容
        std::string content()
        {
            if(!_content)
            {
                return std::string();
            }
            return *_content;
        }
        //修改消息内容
        void content(const std::string& val)
        {
            _content = val;
        }

        //获取文件消息的ID
        std::string file_id() const
        {
            if(!_file_id)
            {
                return std::string();
            }
            return *_file_id;
        }
        //获取文件消息的ID
        std::string file_id()
        {
            if(!_file_id)
            {
                return std::string();
            }
            return *_file_id;
        }
        //修改文件消息的ID
        void file_id(const std::string& val)
        {
            _file_id = val;
        }

        //获取文件消息的名称
        std::string file_name() const
        {
            if(!_file_name)
            {
                return std::string();
            }
            return *_file_name;
        }
        //获取文件消息的名称
        std::string file_name()
        {
            if(!_file_name)
            {
                return std::string();
            }
            return *_file_name;
        }
        //修改文件消息的名称
        void file_name(const std::string& val)
        {
            _file_name = val;
        }

        //获取文件消息的大小
        unsigned int file_size() const
        {
            if(!_file_size)
            {
                return 0;
            }
            return *_file_size;
        }
        //获取文件消息的大小
        unsigned int file_size()
        {
            if(!_file_size)
            {
                return 0;
            }
            return *_file_size;
        }
        //修改文件消息的大小
        void file_size(const unsigned int val)
        {
            _file_size = val;
        }
    private:
        friend class odb::access; //建立友元关系，以便odb框架来访问我们的私有成员

        #pragma db id auto
        unsigned long _id;      //主键

        #pragma db type("varchar(64)") index unique
        std::string _message_id;    //消息ID，是不允许为空的；
        #pragma db type("varchar(64)") index 
        std::string _chat_session_id; //消息的所属会话ID---会使用这个进行过滤，多个消息会属于同一个会话，所以这个字段会重复
        #pragma db type("varchar(64)")
        std::string _user_id;  //消息的发送者ID(消息的来源)，每个用户可以发送多条数据，也不会使用这个字段进行搜索，所以不需要设置为唯一索引
        unsigned char _message_type;    //消息类型：0-文本；1-图片；2-文件；3-语音
        #pragma db type("TIMESTAMP") not_null
        boost::posix_time::ptime _create_time;  //消息的产生时间
        odb::nullable<std::string> _content;   //文本消息---非文本消息可以忽略
        #pragma db type("varchar(64)")
        odb::nullable<std::string> _file_id;    //文件消息的文件ID ---文本消息可以忽略
        #pragma db type("varchar(64)")
        odb::nullable<std::string> _file_name;  //文件消息(语音消息、图片消息、文件消息)的文件名称---只针对文件消息有效
        odb::nullable<unsigned int> _file_size; //文件消息(语音消息、图片消息、文件消息)的文件大小---只针对文件消息有效

    };


}

//odb 编译：odb -d mysql --generate-query --generate-schema --profile boost/date-time message.hxx